import {databus} from '../databus'
// 行走图切换
const mapTile = {
  1: '000-outside.png',
  2: '001-room.png',
  3: '002-maze.png'
};
/**
 * 游戏基础的地图类
 */
export default class Map {
  constructor(imgSrc = '', width = 0, height = 0, x = 0, y = 0,twidth = 0, theight = 0, tx = 0, ty = 0,spriteName = '') {
    
    this.img = new Image()
    this.objImg = new Image()
    this.imgFull = new Image()
    // this.img.src = imgSrc
    this.imgSrc = imgSrc
    this.width = width
    this.height = height

    this.x = x
    this.y = y

    this.twidth = twidth
    this.theight = theight
    this.tx = tx
    this.ty = ty
    this.spriteName = spriteName
    this.dir = imgSrc+"/"

    this.visible = true
    this.frameIndex = 0;
    this.frameLoop = 0;
    // this.readResource()

  }
  
  readResource(convertFlag){
    return new Promise(resolve => {  
      // 先判断文件是否存在
      try {
        const data = require('../../'+this.dir+'0.js')
        // console.log('../../'+this.dir+'0.js',data)
        this.map = data.map
        
        if(convertFlag){
          
          // console.log(this.map.tile_layer)
          if(this.map.tile_layer.tiles){
            this.map.tile_layer.tiles = this.mapTileConvert(this.map.tile_layer.tiles)
          }else{
            for(let i=0;i<this.map.tile_layer.length;i++){
              this.map.tile_layer[i].tiles =  this.mapTileConvert(this.map.tile_layer[i].tiles)
            }
          }
          
          this.map.event_layer.tiles = this.mapConvert('event_layer')
          this.map.obj_layer.obj = this.mapObjConvert('obj_layer')
        }
        databus.worldMap.map = this.map
        // console.log(this.map.event_layer)
        // console.log(this.map.tile_full_layer,this.map.tile_full_layer.tiles[0])
        resolve()
      } catch (error) {
        console.log('文件读取失败:' + error);
      }
  }); 
    
  }

  
  

  /**
   * 将精灵图绘制在canvas上
   */
  drawToCanvas(ctx) {
    
    if (!this.visible) return
    this.twidth = this.twidth==0?this.img.width:this.twidth
    this.theight = this.theight==0?this.img.height:this.theight
    // 绘制地图地板
    
    if(this.map.tile_full_layer){
      this.imgFull = new Image()
      this.imgFull.src = 'images/resource/tileset/'+mapTile[this.map.tile_full_layer.tileset_id]
      for(let i =0;i<this.map.size[0];i++){
        for(let j =0;j<this.map.size[1];j++){
          ctx.drawImage(
            this.imgFull,
            this.map.tile_full_layer.tiles[0].i[2], // 源图像的x坐标
            this.map.tile_full_layer.tiles[0].i[3], // 源图像的y坐标
            16, // 源图像的宽度
            16, // 源图像的高度
            (i-databus.hero.tx)*16*devicePixelRatio, // 目标画布上源图像左上角的 x 坐标
            (j-databus.hero.ty)*16*devicePixelRatio, // 目标画布上源图像左上角的 y 坐标
            16*devicePixelRatio, // 画布上绘制图像的宽度
            16*devicePixelRatio // 画布上绘制图像的高度
          )
        }
      }
    }
    
    // 绘制地图瓷砖
    if(this.map.tile_layer.tiles){
      this.img = new Image()
      this.img.src = 'images/resource/tileset/'+mapTile[this.map.tile_layer.tileset_id]
      for (let tile of this.map.tile_layer.tiles) {
      
        // 循环遍历tile_layer.tiles中的每个对象，获取i的值
        let iValues = tile.i; // 获取i的值
        
  
        ctx.drawImage(
          this.img,
          iValues[2], // 源图像的x坐标
          iValues[3], // 源图像的y坐标
          16, // 源图像的宽度
          16, // 源图像的高度
          (iValues[0]-databus.hero.tx)*16*devicePixelRatio, // 目标画布上源图像左上角的 x 坐标
          (iValues[1]-databus.hero.ty)*16*devicePixelRatio, // 目标画布上源图像左上角的 y 坐标
          16*devicePixelRatio, // 画布上绘制图像的宽度
          16*devicePixelRatio // 画布上绘制图像的高度
        )
      }
    }else{
      for(let j=0;j<this.map.tile_layer.length;j++){
        this.img = new Image()
        this.img.src = 'images/resource/tileset/'+mapTile[this.map.tile_layer[j].tileset_id]
        for (let tile of this.map.tile_layer[j].tiles) {
          
          // 循环遍历tile_layer.tiles中的每个对象，获取i的值
          let iValues = tile.i; // 获取i的值
          ctx.drawImage(
            this.img,
            iValues[2], // 源图像的x坐标
            iValues[3], // 源图像的y坐标
            16, // 源图像的宽度
            16, // 源图像的高度
            (iValues[0]-databus.hero.tx)*16*devicePixelRatio, // 目标画布上源图像左上角的 x 坐标
            (iValues[1]-databus.hero.ty)*16*devicePixelRatio, // 目标画布上源图像左上角的 y 坐标
            16*devicePixelRatio, // 画布上绘制图像的宽度
            16*devicePixelRatio // 画布上绘制图像的高度
          )
        }
      }
    }
    
    // 绘制对象瓷砖，如无极阁、池塘、门
    
    if(this.map.obj_layer.obj&&this.map.obj_layer.obj.length){
      
      for (let tile of this.map.obj_layer.obj) { 
        tile.posDeviation = tile.posDeviation === undefined ? [0,0]:tile.posDeviation
        
        this.objImg = new Image()
        this.objImg.src = 'images/resource/'+tile.path
        // console.log(this.map.obj_layer.pos)
        // 循环遍历tile_layer.tiles中的每个对象，获取i的值
        ctx.drawImage(
          this.objImg,
          0, // 源图像的x坐标
          0, // 源图像的y坐标
          this.objImg.width, // 源图像的宽度
          this.objImg.height, // 源图像的高度
          (tile.pos[0]+tile.posDeviation[0]-databus.hero.tx)*16*devicePixelRatio, // 目标画布上源图像左上角的 x 坐标
          (tile.pos[1]+tile.posDeviation[1]-databus.hero.ty)*16*devicePixelRatio, // 目标画布上源图像左上角的 y 坐标
          this.objImg.width*devicePixelRatio*tile.scale[0], // 画布上绘制图像的宽度
          this.objImg.height*devicePixelRatio*tile.scale[1] // 画布上绘制图像的高度
        )
      }
    }
    
  }
  /**
   * 更新精灵的方法
   * @param {String} type: 精灵的类型
   * @param {int} loop: 是否循环,0循环，否则为执行次数
   */
  update(frame, type, loop) {
    
    // if (frame % 20 === 0) {
    //   this.img = new Image()
    //   this.img.src = 'images/resource/tileset/'+mapTile[this.map.tile_layer.tileset_id]
    // }
  }

  /**
   * 将每个子数组中的最大值替换为0，第二大的值替换为1，依此类推
   * @param{tiles} tiles: tiles
   */
  mapConvert(tile_layer) {
    // 找到数组中第二个数字的最大值
    const maxSecondNumber = this.map.size[1]
    return this.map[tile_layer].tiles.map(function(item) {
      return {i: [item.i[0], maxSecondNumber - item.i[1], item.i[2], item.i[3], item.i[4]]};
    });
  }
   /**
   * 将每个子数组中的最大值替换为0，第二大的值替换为1，依此类推
   * @param{tiles} tiles: tiles
   */
  mapTileConvert(tiles) {
    // 找到数组中第二个数字的最大值
    const maxSecondNumber = this.map.size[1]
    return tiles.map(function(item) {
      return {i: [item.i[0], maxSecondNumber - item.i[1], item.i[2], item.i[3], item.i[4]]};
    });
  }
    /**
   * 将每个子数组中的最大值替换为0，第二大的值替换为1，依此类推
   * @param{tiles} tiles: tiles
   */
  mapObjConvert(obj_layer) {
    // 找到数组中第二个数字的最大值
    
    if(this.map[obj_layer].obj){
      // console.log(this.map[obj_layer].obj)
      const maxSecondNumber = this.map.size[1]
      return this.map[obj_layer].obj.map(function(item) {
        item.posDeviation = item.posDeviation ===undefined ? [0, 0]:item.posDeviation
        return {name:item.name,posDeviation:item.posDeviation,posArea:item.posArea,path:item.path,pos:[item.pos[0],maxSecondNumber-item.pos[1]],scale:item.scale,script:item.script};
      });
    }else {
      return {}
    }
    
  }
  runMapScript(){
    let mapjs = require('../../images/resource/map/'+this.spriteName+'/main.js')
    // console.log(databus)
    mapjs.main()
  }
}
